use reqwest::Client;
use serde_json::{Value, json};
use std::fs;
use tokio::runtime::Runtime;
use futures_util::StreamExt;
use std::collections::HashMap;

/// 调用 DeepSeek API 进行流式输出，返回解析后的 cmd 字段
/// 从根目录下的 deepseek.key 文件读取 API 密钥
/// 从根目录下的 prompt_system.txt 文件读取系统提示词
/// 从函数参数获取用户提示词和模型名称
/// 成功时返回 Some(cmd)，失败时返回 None
pub fn ask_deepseek(user_prompt: &str, model_name: &str) -> Option<String> {
    // 创建异步运行时
    let rt = Runtime::new().unwrap();
    
    // 异步执行 API 调用
    rt.block_on(async {
        // 从文件读取 API 密钥
        let api_key = match fs::read_to_string("/home/qing/文档/dashun/deepseek.key") {
            Ok(key) => key.trim().to_string(),
            Err(e) => {
                eprintln!("无法读取 API 密钥文件: {}", e);
                return None;
            }
        };
        
        if api_key.is_empty() {
            eprintln!("API 密钥文件为空");
            return None;
        }
        
        // 从文件读取系统提示词
        let system_prompt = match fs::read_to_string("/home/qing/文档/dashun/ash/ash/prompt.txt") {
            Ok(prompt) => prompt.trim().to_string(),
            Err(e) => {
                eprintln!("无法读取系统提示词文件: {}", e);
                return None;
            }
        };
        
        // 创建 HTTP 客户端
        let client = Client::new();
        
        // DeepSeek API 端点
        let api_url = "https://api.deepseek.com/chat/completions";
        
        // 准备请求体，强制要求 JSON 格式输出
        let request_body = json!({
            "model": model_name,
            "messages": [
                {
                    "role": "system",
                    "content": system_prompt
                },
                {
                    "role": "system",
                    "content": "你必须以严格的 JSON 格式响应，且只包含一个 'cmd' 字段，其值为要在终端中执行的命令。例如：{\"cmd\": \"ls\"}"
                },
                {
                    "role": "user",
                    "content": user_prompt
                }
            ],
            "response_format": { "type": "json_object" },
            "stream": true
        });
        
        // 发送请求
        let response = match client
            .post(api_url)
            .header("Authorization", format!("Bearer {}", api_key))
            .header("Content-Type", "application/json")
            .json(&request_body)
            .send()
            .await
        {
            Ok(resp) => resp,
            Err(e) => {
                eprintln!("API 请求错误: {}", e);
                return None;
            }
        };
        
        if !response.status().is_success() {
            eprintln!("API 请求失败: {}", response.status());
            return None;
        }
        
        // 处理流式响应
        let mut stream = response.bytes_stream();
        let mut full_response = String::new();
        let mut buffer = String::new();
        
        // 遍历流式数据
        while let Some(chunk) = stream.next().await {
            match chunk {
                Ok(bytes) => {
                    // 将字节转换为字符串
                    if let Ok(chunk_str) = String::from_utf8(bytes.to_vec()) {
                        buffer.push_str(&chunk_str);
                        
                        // 处理缓冲区中的完整行
                        let lines: Vec<&str> = buffer.split('\n').collect();
                        for line in lines.iter().take(lines.len().saturating_sub(1)) {
                            if line.is_empty() {
                                continue;
                            }
                            
                            if line.starts_with("data: ") {
                                let data = &line[6..]; // 去掉 "data: " 前缀
                                if data == "[DONE]" {
                                    break;
                                }
                                
                                // 解析 JSON 数据
                                if let Ok(json) = serde_json::from_str::<Value>(data) {
                                    if let Some(choices) = json["choices"].as_array() {
                                        for choice in choices {
                                            if let Some(delta) = choice["delta"].as_object() {
                                                if let Some(content) = delta.get("content") {
                                                    if let Some(text) = content.as_str() {
                                                        // 输出思考过程到标准错误
                                                        eprint!("{}", text);
                                                        full_response.push_str(text);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        
                        // 保留最后一行（可能不完整）
                        if let Some(last_line) = lines.last() {
                            buffer = last_line.to_string();
                        } else {
                            buffer.clear();
                        }
                    }
                }
                Err(e) => {
                    eprintln!("读取流式响应错误: {}", e);
                    return None;
                }
            }
        }
        
        // 打印换行以清洁标准错误输出
        eprintln!();
        
        // 尝试解析完整的响应为 JSON 并提取 cmd 字段
        match serde_json::from_str::<HashMap<String, String>>(&full_response) {
            Ok(parsed) => {
                if let Some(cmd) = parsed.get("cmd") {
                    Some(cmd.clone())
                } else {
                    eprintln!("响应中未找到 'cmd' 字段");
                    None
                }
            }
            Err(e) => {
                eprintln!("解析响应为 JSON 失败: {}", e);
                eprintln!("原始响应: {}", full_response);
                None
            }
        }
    })
}